Changed the access pattern of flexible arrays from

```rs
let bytes: [u8; 1] = ...;
bytes[10] = ...
```

to

```rs
let bytes: [u8; 1] = ...;
*bytes.as_mut_ptr().add(10) = ...;
```

The original access panics because the bounds are violated, i.e.
accessing the 10th element in an array declared with 1 element. The new
access does not panic, it preserves the C/C++ behavior.

C allows name collision between the following 2 declarations:

```c
struct X {};
typedef enum {} X;
```

The 2 declarations live in different name spaces:

6.2.3 Name spaces of identifiers
[...] there are separate namespaces for various categories of
identifiers, as follows:
1. the tags of structures, unions, and enumerations (disambiguated by
following any) of the keywords struct, union, or enum);
2. all other identifiers, called ordinary identifiers (declared in
ordinary declarators or as enumeration constants).

`struct X {}` lives in namespace 1 and `typedef enum {} X` lives in
namespace 2.

We cannot translate both to `X` in the Rust code. We need to
disambiguate between the 2 names. I chose to translate them as:

```
struct X {} -> X
typedef enum {} X -> X_enum
```

C++ does not have the name space rule for identifiers. I added the
`tag->getASTContext().getLangOpts().CPlusPlus` check in
DisambiguateAnonymousTag to avoid polluting the C++ generated files.

---------

Co-authored-by: Nuno Lopes <nuno.lopes@tecnico.ulisboa.pt>

`"\xff"` or `'\xff'` are valid strings/char literals in C/C++. They were
not escaped and produced an invalid character that broke the
compilation.

After I escaped them, I realized that they cannot be translated to
`\xff` in Rust `str`'s because str only accepts `\x00 - \x7f`. Byte
array accepts `> \x7f`.

I changed Ptr::from_string_literal to accept a byte array instead of a
str. I also changed GetFmtArg to refuse to create Rust `str` that
contains chars `> \x7f` and fallback to GetRawArg that produces escaped
byte arrays.

The generated `Ord::cmp` for method-based `operator<` used
`other.<op>(other)` in its second branch, which can never evaluate true
and therefore suppresses `Ordering::Greater`. This change aligns that
branch with the intended reverse comparison (`other.<op>(self)`),
matching existing model-specific behavior.

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

…st#175)

`const char var[] = {"string literal"}` is a valid initialization. Add
support for it in codegen.

…2Rust#177)

`return std::format("anon_enum_{}", GetLineNumber(enum_decl));` results
in name clashes between enums declared in different files at the same
line, I replaced that with `return GetNamedDeclAsString(enum_decl);`

A continue statement inside a `do while` breakes the iteration and
re-evaluates the condition.

Our previous translation, i.e. 

```rs
loop {
  ...
  if !cond {
    break
  }
}
```

never re-evaluated the condition after a continue, resulting in an
infinite loop.

To fix this, use while instead of loop. This ensures that the condition
is re-evaluated right after the continue:

```rs
let mut __do_while = true;
while __do_while || cond {
  __do_while = false;
  ...
}
```

__do_while makes sure that the first iteration of the loop is always
executed.

…ust#178)

`StrCat` calls were using single-character string literals in many
places (e.g. `">"`-style delimiters and punctuation), which is
inconsistent with the intended char-based usage for single codepoints.
This updates those call sites to pass character literals instead.

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>